{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluating Survival Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*scikit-survival* provides several performance metrics for evaluating survival models:\n",
    "\n",
    "* **Concordance Index (C-index)**: Measures the rank correlation between predicted risk scores and observed event times.\n",
    "  * [concordance_index_censored()](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.concordance_index_censored.html#sksurv.metrics.concordance_index_censored): Implements Harrell's estimator, which can be [optimistic with high censoring](#Bias-of-Harrell's-Concordance-Index).\n",
    "  * [concordance_index_ipcw()](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.concordance_index_ipcw.html#sksurv.metrics.concordance_index_ipcw): An inverse probability of censoring weighted (IPCW) alternative that provides a less biased estimate, especially with high censoring.\n",
    "* **Cumulative/Dynamic Area Under the ROC Curve (AUC)**:\n",
    "  * [cumulative_dynamic_auc()](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.cumulative_dynamic_auc.html#sksurv.metrics.cumulative_dynamic_auc): Extends the AUC to survival data, quantifying how well a model distinguishes subjects who experience an event by a given time from those who do not. It can handle time-dependent risk scores.\n",
    "* **Brier Score**: An extension of the mean squared error to right-censored data, assessing both discrimination and calibration based on a model's estimated survival functions.\n",
    "  * [brier_score()](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.brier_score.html#sksurv.metrics.brier_score): Computes the Brier score at specific time points.\n",
    "  * [integrated_brier_score()](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.integrated_brier_score.html#sksurv.metrics.integrated_brier_score): Provides an overall measure by integrating the Brier score over a range of time points."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Overview of performance metrics available in scikit-survival](/_static/images/metrics-diagram.svg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most frequently used evaluation metric of survival models is the concordance index (c index, c statistic). It is a measure of rank correlation between predicted risk scores $\\hat{f}$ and observed time points $y$ that is closely related to [Kendall’s τ](https://en.wikipedia.org/wiki/Kendall_rank_correlation_coefficient). It is defined as the ratio of correctly ordered (concordant) pairs to comparable pairs.\n",
    "Two samples $i$ and $j$ are comparable if the sample with lower observed time $y$ experienced an event, i.e., if $y_j > y_i$ and $\\delta_i = 1$, where $\\delta_i$ is a binary event indicator. A comparable pair $(i, j)$ is concordant if the estimated risk $\\hat{f}$ by a survival model  is higher for subjects with lower survival time, i.e., $\\hat{f}_i > \\hat{f}_j \\land y_j > y_i$, otherwise the pair is discordant.\n",
    "Harrell's estimator of the c index is implemented in [concordance_index_censored](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.concordance_index_censored.html#sksurv.metrics.concordance_index_censored).\n",
    "\n",
    "While Harrell's concordance index is easy to interpret and compute, it has some shortcomings:\n",
    "1. it has been shown that it is too optimistic with increasing amount of censoring [[1]](https://dx.doi.org/10.1002/sim.4154),\n",
    "2. it is not a useful measure of performance if a specific time range is of primary interest (e.g. predicting death within 2 years).\n",
    "\n",
    "Since version 0.8, scikit-survival supports an alternative estimator of the concordance\n",
    "index from right-censored survival data, implemented in [concordance_index_ipcw](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.concordance_index_ipcw.html#sksurv.metrics.concordance_index_ipcw), that addresses the first issue.\n",
    "\n",
    "The second point can be addressed by extending the well known receiver operating characteristic curve (ROC curve) to possibly censored survival times. Given a time point $t$, we can estimate how well a predictive model can distinguishing subjects who will experience an event by time $t$ (sensitivity) from those who will not (specificity). The function [cumulative_dynamic_auc](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.cumulative_dynamic_auc.html#sksurv.metrics.cumulative_dynamic_auc) implements an estimator of the cumulative/dynamic area under the ROC for a given list of time points.\n",
    "\n",
    "The [first part](#Bias-of-Harrell's-Concordance-Index) of this notebook will illustrate the first issue with simulated survival data, while the [second part](#Time-dependent-Area-under-the-ROC) will focus on the time-dependent area under the ROC applied to data from a real study. Finally, [part three](#Time-dependent-Brier-Score) will discuss the time-dependent Brier score, which is an extension of the mean squared\n",
    "error to [right-censored data](https://scikit-survival.readthedocs.io/en/latest/user_guide/understanding_predictions.html#what-is-survival-analysis)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "from sklearn import set_config\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.pipeline import make_pipeline\n",
    "\n",
    "from sksurv.datasets import load_flchain, load_gbsg2\n",
    "from sksurv.functions import StepFunction\n",
    "from sksurv.linear_model import CoxnetSurvivalAnalysis, CoxPHSurvivalAnalysis\n",
    "from sksurv.metrics import (\n",
    "    concordance_index_censored,\n",
    "    concordance_index_ipcw,\n",
    "    cumulative_dynamic_auc,\n",
    "    integrated_brier_score,\n",
    ")\n",
    "from sksurv.nonparametric import kaplan_meier_estimator\n",
    "from sksurv.preprocessing import OneHotEncoder, encode_categorical\n",
    "from sksurv.util import Surv\n",
    "\n",
    "set_config(display=\"text\")  # displays text representation of estimators\n",
    "plt.rcParams[\"figure.figsize\"] = [7.2, 4.8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bias of Harrell's Concordance Index\n",
    "\n",
    "Harrell's concordance index is known to be biased upwards if the amount of censoring in the test data is high [[1]](https://dx.doi.org/10.1002/sim.4154). [Uno et al](https://dx.doi.org/10.1002/sim.4154) proposed an alternative estimator of the concordance index that behaves better in such situations.\n",
    "In this section, we are going to apply [concordance_index_censored](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.concordance_index_censored.html#sksurv.metrics.concordance_index_censored)\n",
    "and [concordance_index_ipcw](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.concordance_index_ipcw.html#sksurv.metrics.concordance_index_ipcw) to synthetic survival data and compare their results.\n",
    "\n",
    "### Simulation Study\n",
    "\n",
    "We are generating a synthetic biomarker by sampling from a standard normal distribution. For a given hazard ratio, we compute the associated (actual) survival time by drawing from an exponential distribution. The censoring times were generated from a uniform independent distribution $\\textrm{Uniform}(0,\\gamma)$, where we choose $\\gamma$ to produce different amounts of censoring.\n",
    "\n",
    "Since Uno's estimator is based on inverse probability of censoring weighting, we need to estimate the probability of being censored at a given time point. This probability needs to be non-zero for all observed time points. Therefore, we restrict the test data to all samples with observed time lower than the maximum event time $\\tau$. Usually, one would use the `tau` argument of `concordance_index_ipcw` for this, but we apply the selection before to pass identical inputs to `concordance_index_censored` and `concordance_index_ipcw`.\n",
    "The estimates of the concordance index are therefore restricted to the interval $[0, \\tau]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.optimize as opt\n",
    "\n",
    "\n",
    "def generate_marker(n_samples, hazard_ratio, baseline_hazard, rnd):\n",
    "    # create synthetic risk score\n",
    "    X = rnd.standard_normal(size=(n_samples, 1))\n",
    "\n",
    "    # create linear model\n",
    "    hazard_ratio = np.array([hazard_ratio])\n",
    "    logits = np.dot(X, np.log(hazard_ratio))\n",
    "\n",
    "    # draw actual survival times from exponential distribution,\n",
    "    # refer to Bender et al. (2005), https://doi.org/10.1002/sim.2059\n",
    "    u = rnd.uniform(size=n_samples)\n",
    "    time_event = -np.log(u) / (baseline_hazard * np.exp(logits))\n",
    "\n",
    "    # compute the actual concordance in the absence of censoring\n",
    "    X = np.squeeze(X)\n",
    "    actual = concordance_index_censored(np.ones(n_samples, dtype=bool), time_event, X)\n",
    "    return X, time_event, actual[0]\n",
    "\n",
    "\n",
    "def generate_survival_data(n_samples, hazard_ratio, baseline_hazard, percentage_cens, rnd):\n",
    "    X, time_event, actual_c = generate_marker(n_samples, hazard_ratio, baseline_hazard, rnd)\n",
    "\n",
    "    def get_observed_time(x):\n",
    "        [rnd_cens] = rnd.spawn(1)\n",
    "        # draw censoring times\n",
    "        time_censor = rnd_cens.uniform(high=x, size=n_samples)\n",
    "        event = time_event < time_censor\n",
    "        time = np.where(event, time_event, time_censor)\n",
    "        return event, time\n",
    "\n",
    "    def censoring_amount(x):\n",
    "        event, _ = get_observed_time(x)\n",
    "        cens = 1.0 - event.sum() / event.shape[0]\n",
    "        return (cens - percentage_cens) ** 2\n",
    "\n",
    "    # search for upper limit to obtain the desired censoring amount\n",
    "    res = opt.minimize_scalar(censoring_amount, method=\"bounded\", bounds=(0, time_event.max()))\n",
    "\n",
    "    # compute observed time\n",
    "    event, time = get_observed_time(res.x)\n",
    "\n",
    "    # upper time limit such that the probability\n",
    "    # of being censored is non-zero for `t > tau`\n",
    "    tau = time[event].max()\n",
    "    y = Surv.from_arrays(event=event, time=time)\n",
    "    mask = time < tau\n",
    "    X_test = X[mask]\n",
    "    y_test = y[mask]\n",
    "\n",
    "    return X_test, y_test, y, actual_c\n",
    "\n",
    "\n",
    "def simulation(n_samples, hazard_ratio, n_repeats=100):\n",
    "    measures = (\n",
    "        \"censoring\",\n",
    "        \"Harrel's C\",\n",
    "        \"Uno's C\",\n",
    "    )\n",
    "    data_mean = {}\n",
    "    data_std = {}\n",
    "    for measure in measures:\n",
    "        data_mean[measure] = []\n",
    "        data_std[measure] = []\n",
    "\n",
    "    rnd = np.random.default_rng(seed=20211229)\n",
    "    # iterate over different amount of censoring\n",
    "    for cens in (0.1, 0.25, 0.4, 0.5, 0.6, 0.7):\n",
    "        data = {\n",
    "            \"censoring\": [],\n",
    "            \"Harrel's C\": [],\n",
    "            \"Uno's C\": [],\n",
    "        }\n",
    "\n",
    "        # repeaditly perform simulation\n",
    "        for _ in range(n_repeats):\n",
    "            # generate data\n",
    "            X_test, y_test, y_train, actual_c = generate_survival_data(\n",
    "                n_samples, hazard_ratio, baseline_hazard=0.1, percentage_cens=cens, rnd=rnd\n",
    "            )\n",
    "\n",
    "            # estimate c-index\n",
    "            c_harrell = concordance_index_censored(y_test[\"event\"], y_test[\"time\"], X_test)\n",
    "            c_uno = concordance_index_ipcw(y_train, y_test, X_test)\n",
    "\n",
    "            # save results\n",
    "            data[\"censoring\"].append(100.0 - y_test[\"event\"].sum() * 100.0 / y_test.shape[0])\n",
    "            data[\"Harrel's C\"].append(actual_c - c_harrell[0])\n",
    "            data[\"Uno's C\"].append(actual_c - c_uno[0])\n",
    "\n",
    "        # aggregate results\n",
    "        for key, values in data.items():\n",
    "            data_mean[key].append(np.mean(data[key]))\n",
    "            data_std[key].append(np.std(data[key], ddof=1))\n",
    "\n",
    "    data_mean = pd.DataFrame.from_dict(data_mean)\n",
    "    data_std = pd.DataFrame.from_dict(data_std)\n",
    "    return data_mean, data_std\n",
    "\n",
    "\n",
    "def plot_results(data_mean, data_std, **kwargs):\n",
    "    index = pd.Index(data_mean[\"censoring\"].round(3), name=\"mean percentage censoring\")\n",
    "    for df in (data_mean, data_std):\n",
    "        df.drop(\"censoring\", axis=1, inplace=True)\n",
    "        df.index = index\n",
    "\n",
    "    ax = data_mean.plot.bar(yerr=data_std, **kwargs)\n",
    "    ax.set_ylabel(\"Actual C - Estimated C\")\n",
    "    ax.yaxis.grid(True)\n",
    "    ax.axhline(0.0, color=\"gray\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us assume a moderate hazard ratio of 2 and generate a small synthetic dataset of 100 samples from which we estimate the concordance index. We repeat this experiment 200 times and plot mean and standard deviation of the difference between the *actual* (in the absence of censoring) and *estimated* concordance index.\n",
    "\n",
    "Since the hazard ratio remains constant and only the amount of censoring changes, we would want an estimator for which the difference between the actual and estimated c to remain approximately constant across simulations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 518.4x345.6 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "hazard_ratio = 2.0\n",
    "ylim = [-0.035, 0.035]\n",
    "mean_1, std_1 = simulation(100, hazard_ratio)\n",
    "plot_results(mean_1, std_1, ylim=ylim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can observe that estimates are on average below the actual value, except for the highest amount of censoring, where Harrell's c begins overestimating the performance (on average).\n",
    "\n",
    "With such a small dataset, the variance of differences is quite big, so let us increase the amount of data to 1000 and repeat the simulation (*this may take some time*)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 518.4x345.6 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mean_2, std_2 = simulation(1000, hazard_ratio)\n",
    "plot_results(mean_2, std_2, ylim=ylim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can observe that Harrell's c begins to overestimate performance starting with approximately 49% censoring while Uno's c is still underestimating the performance, but is on average very close to the actual performance for large amounts of censoring.\n",
    "\n",
    "For the final experiment, we double the size of the dataset to 2000 samples and repeat the analysis (*this may take several minutes to compute*)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 518.4x345.6 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mean_3, std_3 = simulation(2000, hazard_ratio)\n",
    "plot_results(mean_3, std_3, ylim=ylim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The trend we observed in the previous simulation is now even more pronounced.\n",
    "Harrell's c is becoming more and more overconfident in the performance of the synthetic marker with increasing amount of censoring, while Uno's c remains stable.\n",
    "\n",
    "In summary, while the difference between [concordance_index_ipcw](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.concordance_index_ipcw.html#sksurv.metrics.concordance_index_ipcw)\n",
    "and [concordance_index_censored](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.concordance_index_censored.html#sksurv.metrics.concordance_index_censored) is negligible for small amounts of censoring, when analyzing survival data with moderate to high amounts of censoring, you might want to consider estimating the performance using `concordance_index_ipcw` instead of `concordance_index_censored`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Time-dependent Area under the ROC\n",
    "\n",
    "The area under the [receiver operating characteristics curve](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) (ROC curve) is a popular performance measure for binary classification task. In the medical domain, it is often used to determine how well estimated risk scores can separate diseased patients (cases) from healthy patients (controls). Given a predicted risk score $\\hat{f}$, the ROC curve compares the false positive rate (1 - specificity) against the true positive rate (sensitivity) for each possible value of $\\hat{f}$.\n",
    "\n",
    "When extending the ROC curve to continuous outcomes, in particular survival time, a patient’s disease status is typically not fixed and changes over time: at enrollment a subject is usually healthy, but may be diseased at some later time point. Consequently, sensitivity and specificity become [time-dependent measures](http://dx.doi.org/10.1111/j.0006-341x.2000.00337.x).\n",
    "Here, we consider *cumulative cases* and *dynamic controls* at a given time point $t$, which gives rise to the time-dependent cumulative/dynamic ROC at time $t$.\n",
    "Cumulative cases are all individuals that experienced an event prior to or at time $t$ ($t_i \n",
    "\\leq t$), whereas dynamic controls are those with $t_i>t$.\n",
    "By computing the area under the cumulative/dynamic ROC at time $t$, we can determine how well a model can distinguish subjects who fail by a given time ($t_i \\leq t$) from subjects who fail after this time ($t_i>t$).\n",
    "Hence, it is most relevant if one wants to predict the occurrence of an event in a period up to time $t$ rather than at a specific time point $t$.\n",
    "\n",
    "The [cumulative_dynamic_auc](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.cumulative_dynamic_auc.html#sksurv.metrics.cumulative_dynamic_auc) function implements an estimator of the cumulative/dynamic area under the ROC at a given list of time points.\n",
    "To illustrate its use, we are going to use data from a [study](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3538473/) that investigated to which extent the serum immunoglobulin free light chain (FLC) assay can be used predict overall survival. The dataset has 7874 subjects and 9 features; the endpoint is death, which occurred for 2169 subjects (27.5%).\n",
    "\n",
    "First, we are loading the data and split it into train and test set to evaluate how well markers generalize."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = load_flchain()\n",
    "\n",
    "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Serum creatinine measurements are missing for some patients, therefore we are just going to impute these values with the mean using scikit-learn's `SimpleImputer`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_columns = [\"age\", \"creatinine\", \"kappa\", \"lambda\"]\n",
    "\n",
    "imputer = SimpleImputer().fit(x_train.loc[:, num_columns])\n",
    "x_test_imputed = imputer.transform(x_test.loc[:, num_columns])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to Uno's estimator of the concordance index described above, we need to be a little bit careful when selecting the test data and time points we want to evaluate the ROC at, due to the estimator's dependence on inverse probability of censoring weighting.\n",
    "First, we are going to check whether the observed time of the test data lies within the observed time range of the training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_events = y_train[y_train[\"death\"]]\n",
    "train_min, train_max = y_events[\"futime\"].min(), y_events[\"futime\"].max()\n",
    "\n",
    "y_events = y_test[y_test[\"death\"]]\n",
    "test_min, test_max = y_events[\"futime\"].min(), y_events[\"futime\"].max()\n",
    "\n",
    "assert (\n",
    "    train_min <= test_min < test_max < train_max\n",
    "), \"time range or test data is not within time range of training data.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When choosing the time points to evaluate the ROC at, it is important to remember to choose the last time point such that the probability of being censored after the last time point is non-zero. In the simulation study above, we set the upper bound to the maximum event time, here we use a more conservative approach by setting the upper bound to the 80% percentile of observed time points, because the censoring rate is quite large at 72.5%.\n",
    "Note that this approach would be appropriate for choosing `tau` of  [concordance_index_ipcw](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.concordance_index_ipcw.html#sksurv.metrics.concordance_index_ipcw) too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 470.3        1259.         1998.         2464.82428571 2979.\n",
      " 3401.         3787.99857143 4051.         4249.         4410.17285714\n",
      " 4543.         4631.         4695.         4781.         4844.        ]\n"
     ]
    }
   ],
   "source": [
    "times = np.percentile(y[\"futime\"], np.linspace(5, 81, 15))\n",
    "print(times)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We begin by considering individual real-valued features as risk scores without actually fitting a survival model. Hence, we obtain an estimate of how well *age*, *creatinine*, *kappa* FLC, and *lambda* FLC are able to distinguish cases from controls at each time point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 518.4x345.6 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_cumulative_dynamic_auc(risk_score, label, color=None):\n",
    "    auc, mean_auc = cumulative_dynamic_auc(y_train, y_test, risk_score, times)\n",
    "\n",
    "    plt.plot(times, auc, marker=\"o\", color=color, label=label)\n",
    "    plt.xlabel(\"days from enrollment\")\n",
    "    plt.ylabel(\"time-dependent AUC\")\n",
    "    plt.axhline(mean_auc, color=color, linestyle=\"--\")\n",
    "    plt.legend()\n",
    "\n",
    "\n",
    "for i, col in enumerate(num_columns):\n",
    "    plot_cumulative_dynamic_auc(x_test_imputed[:, i], col, color=f\"C{i}\")\n",
    "    ret = concordance_index_ipcw(y_train, y_test, x_test_imputed[:, i], tau=times[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The plot shows the estimated area under the time-dependent ROC at each time point and the average across all time points as dashed line.\n",
    "\n",
    "We can see that age is overall the most discriminative feature, followed by $\\kappa$ and $\\lambda$ FLC. That fact that age is the strongest predictor of overall survival in the general population is hardly surprising (we have to die at some point after all). \n",
    "More differences become evident when considering time: the discriminative power of FLC decreases at later time points, while that of age increases. The observation for age again follows common sense. In contrast, FLC seems to be a good predictor of death in the near future, but not so much if it occurs decades later.\n",
    "\n",
    "### Evaluating a Model's Predictions\n",
    "\n",
    "Most of the time, we do not want to evaluate the discriminatory power of individual features, but how a predictive model performs, based on many features. To demonstrate this, we will fit a survival model to predict the risk of death from the [Veterans' Administration Lung Cancer Trial](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.datasets.load_veterans_lung_cancer.html#sksurv.datasets.load_veterans_lung_cancer).\n",
    "\n",
    "First, we split the data into 80% for training and 20% for testing and use the `stratify` option to ensure\n",
    "that we do not end up with test data only containing censored death times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sksurv.datasets import load_veterans_lung_cancer\n",
    "\n",
    "va_x, va_y = load_veterans_lung_cancer()\n",
    "\n",
    "va_x_train, va_x_test, va_y_train, va_y_test = train_test_split(\n",
    "    va_x, va_y, test_size=0.2, stratify=va_y[\"Status\"], random_state=0\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we fit a Cox proportional hazards model to the training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('onehotencoder', OneHotEncoder()),\n",
       "                ('coxphsurvivalanalysis', CoxPHSurvivalAnalysis())])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cph = make_pipeline(OneHotEncoder(), CoxPHSurvivalAnalysis())\n",
    "cph.fit(va_x_train, va_y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the test data, we want to assess how well the model can distinguish survivors from deceased in weekly intervals, up to 6 months after enrollment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 518.4x345.6 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "va_times = np.arange(8, 184, 7)\n",
    "cph_risk_scores = cph.predict(va_x_test)\n",
    "cph_auc, cph_mean_auc = cumulative_dynamic_auc(va_y_train, va_y_test, cph_risk_scores, va_times)\n",
    "\n",
    "plt.plot(va_times, cph_auc, marker=\"o\")\n",
    "plt.axhline(cph_mean_auc, linestyle=\"--\")\n",
    "plt.xlabel(\"days from enrollment\")\n",
    "plt.ylabel(\"time-dependent AUC\")\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The plot shows that the model is doing moderately well on average with an AUC of ~0.72 (dashed line). However, there is a clear difference in performance between the first and second half of the time range. The performance on the test data increases up to 56 days from enrollment, remains high until 98 days and quickly drops thereafter. Thus, we can conclude that the model is most effective in predicting death in the medium-term.\n",
    "\n",
    "### Using Time-dependent Risk Scores\n",
    "\n",
    "The downside of Cox proportional hazards model is that it can only predict a risk score that is independent of time (due to the built-in proportional hazards assumption). Therefore, a single predicted risk score needs to work well for *every* time point. In contrast, a Random Survival Forest does not have this restriction. So let's fit such a model to the training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('onehotencoder', OneHotEncoder()),\n",
       "                ('randomsurvivalforest',\n",
       "                 RandomSurvivalForest(min_samples_leaf=7, random_state=0))])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sksurv.ensemble import RandomSurvivalForest\n",
    "\n",
    "rsf = make_pipeline(OneHotEncoder(), RandomSurvivalForest(n_estimators=100, min_samples_leaf=7, random_state=0))\n",
    "rsf.fit(va_x_train, va_y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For prediction, we do not call [predict](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.ensemble.RandomSurvivalForest.html#sksurv.ensemble.RandomSurvivalForest.predict), which returns a time-independent risk score, but call [predict_cumulative_hazard_function](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.ensemble.RandomSurvivalForest.html#sksurv.ensemble.RandomSurvivalForest.predict_cumulative_hazard_function), which returns a risk function over time for each patient. We obtain the time-dependent risk scores by evaluating each cumulative hazard function at the time points we are interested in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "rsf_chf_funcs = rsf.predict_cumulative_hazard_function(va_x_test, return_array=False)\n",
    "rsf_risk_scores = np.vstack([chf(va_times) for chf in rsf_chf_funcs])\n",
    "\n",
    "rsf_auc, rsf_mean_auc = cumulative_dynamic_auc(va_y_train, va_y_test, rsf_risk_scores, va_times)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can compare the result with the predictive performance of the Cox proportional hazards model from above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 518.4x345.6 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(va_times, cph_auc, \"o-\", label=f\"CoxPH (mean AUC = {cph_mean_auc:.3f})\")\n",
    "plt.plot(va_times, rsf_auc, \"o-\", label=f\"RSF (mean AUC = {rsf_mean_auc:.3f})\")\n",
    "plt.xlabel(\"days from enrollment\")\n",
    "plt.ylabel(\"time-dependent AUC\")\n",
    "plt.legend(loc=\"lower center\")\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indeed, the Random Survival Forest performs slightly better on average, mostly due to the better performance in the intervals 25–50 days, and 112–147 days. Above 147 days, it actually is doing worse. This shows that the mean AUC is convenient to assess overall performance, but it can hide interesting characteristics that only become visible when looking at the AUC at individual time points.\n",
    "\n",
    "## Time-dependent Brier Score\n",
    "\n",
    "The time-dependent Brier score is an extension of the mean squared\n",
    "error to [right censored data](https://scikit-survival.readthedocs.io/en/latest/user_guide/understanding_predictions.html#what-is-survival-analysis). Given a time point $t$, it is defined as:\n",
    "\n",
    "$$\n",
    "\\mathrm{BS}^c(t) = \\frac{1}{n} \\sum_{i=1}^n I(y_i \\leq t \\land \\delta_i = 1)\n",
    "        \\frac{(0 - \\hat{\\pi}(t | \\mathbf{x}_i))^2}{\\hat{G}(y_i)} + I(y_i > t)\n",
    "        \\frac{(1 - \\hat{\\pi}(t | \\mathbf{x}_i))^2}{\\hat{G}(t)} ,\n",
    "$$\n",
    "\n",
    "where $\\hat{\\pi}(t | \\mathbf{x})$ is a model's predicted probability of\n",
    "remaining event-free up to time point $t$ for feature vector $\\mathbf{x}$, and $1/\\hat{G}(t)$ is an inverse probability of censoring weight.\n",
    "\n",
    "*Note that the time-dependent Brier score is only\n",
    "applicable for models that are able to estimate a survival function.\n",
    "For instance, it cannot be used with* [Survival Support Vector Machines](https://scikit-survival.readthedocs.io/en/latest/api/svm.html#survival-support-vector-machine).\n",
    "\n",
    "The Brier score is often used to assess calibration.\n",
    "If a model predicts a 10% risk of experiencing an\n",
    "event at time $t$, the observed frequency in the data\n",
    "should match this percentage for a well calibrated model.\n",
    "In addition, the Brier score is also a measure of\n",
    "discrimination: whether a model is able to predict risk scores\n",
    "that allow us to correctly determine the order of events.\n",
    "The concordance index is probably the most common measure\n",
    "of discrimination. However, the concordance index disregards\n",
    "the actual values of predicted risk scores\n",
    "– it is a ranking metric –\n",
    "and is unable to tell us anything about calibration.\n",
    "\n",
    "Let's consider an example based on data from the\n",
    "[German Breast Cancer Study Group 2](http://ascopubs.org/doi/abs/10.1200/jco.1994.12.10.2086)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "gbsg_X, gbsg_y = load_gbsg2()\n",
    "gbsg_X = encode_categorical(gbsg_X)\n",
    "\n",
    "gbsg_X_train, gbsg_X_test, gbsg_y_train, gbsg_y_test = train_test_split(\n",
    "    gbsg_X, gbsg_y, stratify=gbsg_y[\"cens\"], random_state=1\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to train a model on the training data and assess\n",
    "its discrimination and calibration on the test data.\n",
    "Here, we consider a [Random Survival Forest](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.ensemble.RandomSurvivalForest.html#sksurv.ensemble.RandomSurvivalForest)\n",
    "and [Cox's proportional hazards model with elastic-net penalty](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.linear_model.CoxnetSurvivalAnalysis.html#sksurv.linear_model.CoxnetSurvivalAnalysisl)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CoxnetSurvivalAnalysis(fit_baseline_model=True, l1_ratio=0.99)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rsf_gbsg = RandomSurvivalForest(max_depth=2, random_state=1)\n",
    "rsf_gbsg.fit(gbsg_X_train, gbsg_y_train)\n",
    "\n",
    "cph_gbsg = CoxnetSurvivalAnalysis(l1_ratio=0.99, fit_baseline_model=True)\n",
    "cph_gbsg.fit(gbsg_X_train, gbsg_y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, let's start with discrimination as measured by the\n",
    "concordance index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RSF       0.692\n",
       "CPH       0.688\n",
       "Random    0.500\n",
       "Name: c-index, dtype: float64"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "score_cindex = pd.Series(\n",
    "    [\n",
    "        rsf_gbsg.score(gbsg_X_test, gbsg_y_test),\n",
    "        cph_gbsg.score(gbsg_X_test, gbsg_y_test),\n",
    "        0.5,\n",
    "    ],\n",
    "    index=[\"RSF\", \"CPH\", \"Random\"],\n",
    "    name=\"c-index\",\n",
    ")\n",
    "\n",
    "score_cindex.round(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result indicates that both models perform almost equally well\n",
    "with Cox's proportional hazards model achieving a concordance index of 0.688\n",
    "and Random Survival Forest of 0.692, both of which are significantly\n",
    "better than a random model with 0.5 concordance index.\n",
    "Unfortunately, it doesn't help us to decide which model we should\n",
    "choose. So let's consider the time-dependent Brier score\n",
    "as an alternative, which asses discrimination *and* calibration.\n",
    "\n",
    "We first need to determine for which time points\n",
    "$t$ we want to compute the Brier score for. We are going to use a data-driven\n",
    "approach here by selecting all time points between the 10% and 90%\n",
    "percentile of observed time points.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "lower, upper = np.percentile(gbsg_y[\"time\"], [10, 90])\n",
    "gbsg_times = np.arange(lower, upper + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This returns 1690 time points, for which we need to estimate the\n",
    "probability of survival for, which is given by the survival function.\n",
    "Thus, we iterate over the predicted survival functions on the test data\n",
    "and evaluate each at the time points from above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "rsf_surv_prob = np.vstack([fn(gbsg_times) for fn in rsf_gbsg.predict_survival_function(gbsg_X_test)])\n",
    "cph_surv_prob = np.vstack([fn(gbsg_times) for fn in cph_gbsg.predict_survival_function(gbsg_X_test)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition, we want to have a baseline to tell us how much better\n",
    "our models are from random. A random model would simply predict 0.5\n",
    "every time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_surv_prob = 0.5 * np.ones((gbsg_y_test.shape[0], gbsg_times.shape[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another useful reference is the Kaplan-Meier estimator that does not consider\n",
    "any features: it estimates a survival function only from `gbsg_y_test`.\n",
    "We replicate this estimate for all samples in the test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "km_func = StepFunction(*kaplan_meier_estimator(gbsg_y_test[\"cens\"], gbsg_y_test[\"time\"]))\n",
    "km_surv_prob = np.tile(km_func(gbsg_times), (gbsg_y_test.shape[0], 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of comparing calibration across all 1690 time points, we'll be\n",
    "using the\n",
    "[integrated Brier score](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.integrated_brier_score.html#sksurv.metrics.integrated_brier_score)\n",
    "(IBS) over all time points, which will\n",
    "give us a single number to compare the models by.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>c-index</th>\n",
       "      <th>IBS</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RSF</th>\n",
       "      <td>0.692</td>\n",
       "      <td>0.192</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CPH</th>\n",
       "      <td>0.688</td>\n",
       "      <td>0.189</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Random</th>\n",
       "      <td>0.500</td>\n",
       "      <td>0.247</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Kaplan-Meier</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0.217</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              c-index    IBS\n",
       "RSF             0.692  0.192\n",
       "CPH             0.688  0.189\n",
       "Random          0.500  0.247\n",
       "Kaplan-Meier      NaN  0.217"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "score_brier = pd.Series(\n",
    "    [\n",
    "        integrated_brier_score(gbsg_y, gbsg_y_test, prob, gbsg_times)\n",
    "        for prob in (rsf_surv_prob, cph_surv_prob, random_surv_prob, km_surv_prob)\n",
    "    ],\n",
    "    index=[\"RSF\", \"CPH\", \"Random\", \"Kaplan-Meier\"],\n",
    "    name=\"IBS\",\n",
    ")\n",
    "\n",
    "pd.concat((score_cindex, score_brier), axis=1).round(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Despite Random Survival Forest and Cox's proportional hazards model\n",
    "performing equally well in terms of discrimination (c-index), there seems to be\n",
    "a notable difference in terms of calibration (IBS), with\n",
    "Cox's proportional hazards model outperforming Random Survival Forest."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Metrics in Hyper-parameter Search\n",
    "\n",
    "Usually, estimators have hyper-parameters that one wants to optimize. For example, the maximum tree depth for tree-based learners. For this purpose, we can use scikit-learn's [GridSearchCV](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html#sklearn.model_selection.GridSearchCV) to search for the hyper-parameter configuration that on average works best. By default, estimators' performance will be evaluated in terms of Harrell's concordance index, as implemented in [concordance_index_censored](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.concordance_index_censored.html#sksurv.metrics.concordance_index_censored).\n",
    "For other metrics, one can wrap an estimator with one of the following classes:\n",
    "\n",
    "- [as_concordance_index_ipcw_scorer](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.as_concordance_index_ipcw_scorer.html#sksurv.metrics.as_concordance_index_ipcw_scorer)\n",
    "- [as_cumulative_dynamic_auc_scorer](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.as_cumulative_dynamic_auc_scorer.html#sksurv.metrics.as_cumulative_dynamic_auc_scorer)\n",
    "- [as_integrated_brier_score_scorer](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.as_integrated_brier_score_scorer.html#sksurv.metrics.as_integrated_brier_score_scorer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import GridSearchCV, KFold\n",
    "\n",
    "from sksurv.metrics import (\n",
    "    as_concordance_index_ipcw_scorer,\n",
    "    as_cumulative_dynamic_auc_scorer,\n",
    "    as_integrated_brier_score_scorer,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To illustrate this, we are going to use the Random Survival Forest and the\n",
    "[German Breast Cancer Study Group 2](http://ascopubs.org/doi/abs/10.1200/jco.1994.12.10.2086) from above.\n",
    "\n",
    "First, we define that we want to evaluate the performance of each hyper-parameter configuration by 3-fold cross-validation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv = KFold(n_splits=3, shuffle=True, random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we define the set of hyper-parameters to evaluate. Here, we search for the best value for ``max_depth`` between 1 and 10 (excluding). Note that we have to prefix ``max_depth`` with ``estimator__``, because we are going to wrap the actual ``RandomSurvivalForest`` instance with one of the classes above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv_param_grid = {\n",
    "    \"estimator__max_depth\": np.arange(1, 10, dtype=int),\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can put all the pieces together and start searching for the best hyper-parameters that maximize [concordance_index_ipcw](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.concordance_index_ipcw.html#sksurv.metrics.concordance_index_ipcw)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "gcv_cindex = GridSearchCV(\n",
    "    as_concordance_index_ipcw_scorer(rsf_gbsg, tau=gbsg_times[-1]),\n",
    "    param_grid=cv_param_grid,\n",
    "    cv=cv,\n",
    ").fit(gbsg_X, gbsg_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same process applies when optimizing hyper-parameters to maximize\n",
    "[cumulative_dynamic_auc](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.cumulative_dynamic_auc.html#sksurv.metrics.cumulative_dynamic_auc)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "gcv_iauc = GridSearchCV(\n",
    "    as_cumulative_dynamic_auc_scorer(rsf_gbsg, times=gbsg_times),\n",
    "    param_grid=cv_param_grid,\n",
    "    cv=cv,\n",
    ").fit(gbsg_X, gbsg_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While [as_concordance_index_ipcw_scorer](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.as_concordance_index_ipcw_scorer.html#sksurv.metrics.as_concordance_index_ipcw_scorer)\n",
    "and [as_cumulative_dynamic_auc_scorer](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.as_cumulative_dynamic_auc_scorer.html#sksurv.metrics.as_cumulative_dynamic_auc_scorer)\n",
    "can be used with any estimator,\n",
    "[as_integrated_brier_score_scorer](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.as_integrated_brier_score_scorer.html#sksurv.metrics.as_integrated_brier_score_scorer) is only available for estimators that provide the ``predict_survival_function`` method, which includes ``RandomSurvivalForest``. If available, hyper-parameters that maximize the **negative** integrated time-dependent Brier score will be selected, because a lower Brier score indicates better performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "gcv_ibs = GridSearchCV(\n",
    "    as_integrated_brier_score_scorer(rsf_gbsg, times=gbsg_times),\n",
    "    param_grid=cv_param_grid,\n",
    "    cv=cv,\n",
    ").fit(gbsg_X, gbsg_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can visualize the results of the grid search and compare the best performing hyper-parameter configurations (marked with a red dot)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x432 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_grid_search_results(gcv, ax, name):\n",
    "    ax.errorbar(\n",
    "        x=gcv.cv_results_[\"param_estimator__max_depth\"].filled(),\n",
    "        y=gcv.cv_results_[\"mean_test_score\"],\n",
    "        yerr=gcv.cv_results_[\"std_test_score\"],\n",
    "    )\n",
    "    ax.plot(\n",
    "        gcv.best_params_[\"estimator__max_depth\"],\n",
    "        gcv.best_score_,\n",
    "        \"ro\",\n",
    "    )\n",
    "    ax.set_ylabel(name)\n",
    "    ax.yaxis.grid(True)\n",
    "\n",
    "\n",
    "_, axs = plt.subplots(3, 1, figsize=(6, 6), sharex=True)\n",
    "axs[-1].set_xlabel(\"max_depth\")\n",
    "\n",
    "plot_grid_search_results(gcv_cindex, axs[0], \"c-index\")\n",
    "plot_grid_search_results(gcv_iauc, axs[1], \"iAUC\")\n",
    "plot_grid_search_results(gcv_ibs, axs[2], \"$-$IBS\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When optimizing for the concordance index, a high maximum depth works best, whereas the other metrics are best when choosing a maximum depth of 5 and 8, respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "I hope this notebook helped you to understand some of the pitfalls when estimating the performance of markers and models from right-censored survival data. We illustrated that [Harrell's estimator](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.concordance_index_censored.html#sksurv.metrics.concordance_index_censored) of the concordance index is biased when the amount of censoring is high, and that [Uno's estimator](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.concordance_index_ipcw.html#sksurv.metrics.concordance_index_ipcw) is more appropriate in this situation. Finally, we demonstrated that the [time-dependent area under the ROC](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.cumulative_dynamic_auc.html#sksurv.metrics.cumulative_dynamic_auc) is a very useful tool when we want to predict the occurrence of an event in a period up to time $t$ rather than at a specific time point $t$. Finally, the [integrated time-dependent Brier score](https://scikit-survival.readthedocs.io/en/latest/api/generated/sksurv.metrics.integrated_brier_score.html#sksurv.metrics.integrated_brier_score) is an extension of the mean squared error that can measure discrimination *and* calibration."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
